<?php

class GestioneController extends Zend_Controller_Action {

    public function init() {
        /* Initialize action controller here */
    }

    public function indexAction() {
        // action body
        $auth = Zend_Auth::getInstance();
        if ($auth->hasIdentity()) {
            $id = $auth->getIdentity()->id_utente;

            $admin = new Application_Model_DbTable_Administrator();
            $this->view->admin = $admin->getAdmin($id);
        } else {
            $this->_forward('index', 'Auth');
        }
    }

    /**
     * Questo metodo restituisce il flusso corrente di un processo sanzionatorio
     *
     *
     */
    public function getFlussoAction() {
        
        $session = new Zend_Session_Namespace('id_persona');
        $id_persona = $session->id_persona;  
        $this->view->top_persona = $this->view->getInfoPersona($id_persona);                    
        
        $auth = Zend_Auth::getInstance();
        if ($auth->hasIdentity()) {
            // dati
            $flusso_id = null; // id fase per il flusso (array )
            $flusso_nome = null; // nome fase per il flusso ( array )
            $azioni_associate = null; // tutte le azioni associate ad ogni flusso (array => array )
            $azioni_eseguite = null; // se l'azione è stata eseguita o no (array => array)
            $fase_effettuata = null; // vettore che conterra se la fase $i è stata effettuata o no
            $fasi_seguenti = null; // fasi seguenti se una fase è stata effettuata
            $id_processo = $this->_getParam('id', 'nid');
            // id processo sanzionatorio (preso poi con il get)
            if ($id_processo != 'nid') { // se ho un processo in input
                // db flusso
                require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
                $db_flusso = new Flusso_db();
                $ret = $db_flusso->getProcessoDaId($id_processo);
                $id_tipo_processo = $ret['id_lib_tipo_processo_sanzionatorio'];
                $fase_attuale = $ret['id_fase_attuale'];

                //prendo l'id radice del processo
                // stampo tutto fino allo stato attuale
                // classe utility
                require_once APPLICATION_PATH . '/models/Db/Utility.php';
                $utility = new Utility();
                $utility->crea_percorso_da_fase($fase_attuale);
                $flusso_id = $utility->get_flusso();
                $flusso_nome = $utility->get_nomi_flusso();

                // prendo le azioni associate ad ogni fase
                foreach ($flusso_nome as $key => $flusso) {
                    $azioni_associate[$key] = $db_flusso->getAzioniDaIdFase($flusso_id[$key]);
                }

                // gestione azioni eseguite già
                // creo un vettore se azione è stata eseguita o no
                foreach ($azioni_associate as $key => $azione) { // azioni di ogni fase
                    $fase_effettuata[$key] = 0; // all'inizio non è effettuata
                    $non_compiuta = 0; // se esiste una azione non compiuta
                    foreach ($azione as $key2 => $valore) { // ogni azione
                        // se è un azione_eseguita per lo stesso processo la flaggo come eseguita
                        //echo $valore['id_azione'];
                        $eseguita = $db_flusso->getAzioneEseguita($valore['id_azione'], $id_processo);
                        if ($eseguita)
                            $azioni_eseguite[$key][$key2] = 1;
                        else {
                            $non_compiuta = 1;
                            $azioni_eseguite[$key][$key2] = 0;
                        }
                    }
                    if ($non_compiuta == 0)
                        $fase_effettuata[$key] = 1;
                    else
                        $fase_effettuata[$key] = 0;
                }
//                echo "<pre>";
//                print_r($azioni_eseguite);
//                echo "</pre>";
//                echo "<pre>";                
//                
//                print_r($fase_effettuata);
//                echo "</pre>";                
                // se la fase corrente è effettuata faccio la proposta di nuove fasi
                if (end($fase_effettuata) == 1) {
                    $fasi_seguenti = $db_flusso->getNodiFigli($id_processo, end($flusso_id));
                    //print_r($fasi_seguenti);
                }

                // gestione peso azioni e propedeuticità DA FARE
            } else {
                echo "errore: manca l'id processo";
            }



            // CODICE VECCHIO
            /*         $MAX_CICLI = 999; // per evitare overflow
              $TipoProcessoSanzionatorio = 1; //id processo sanzionatorio, per distinguere i vari flussi
              // successivamente arriva da input
              $idRadice = "1"; // necessario per sapere da dove partire con l'iter, contiene id Fase è anche la fase con padre 0
              $nodoCorrente = $idRadice; // id del nodo corrente dal quale si fa seguire il percorso
              $flussoId[] = null; // array dove memorizzo tutti gli idFasi del flusso (ARRAY PARALLELI)
              $flussoNome[] = null; // array che contiene i nomi del flusso (ARRAY PARALLELI)
              // classe necessaria per l'accesso al db
              require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
              require_once APPLICATION_PATH . '/models/Db/Utility.php';
              $utility=new Utility();
              $db=new Flusso_db();
              $utility->padre_figlio_walk($idRadice, $TipoProcessoSanzionatorio);
              $flusso_id=$utility->get_flusso();
              $flusso_nome=$utility->get_nomi_flusso();
              //print_r($flusso_nome);
              foreach($flusso_nome as $key => $flusso){
              $azioni_associate[$key]=$db->getAzioniDaIdFase($flusso_id[$key]);
              }
              //var_dump($flusso_id);

              // corpo
              /**  for ($i = 0; !is_null($nodoCorrente) && $i < $MAX_CICLI; $i++) { /* se c'è nodo successore o arrivo al max cicli */
            /* appende al flusso nodo corrente e imposta il nuovo nodo corrente come successore
             *
             * ATTENZIONE: si assume che ogni nodo abbia un solo 
             * padre.
             */

            // get dati
            // creo oggetto interazione db
            /**   $db = new Flusso_db();
              // ottengo il dati della fase corrente
              $fase = $db->getFaseDaId($nodoCorrente);
              // aggiungo al flusso
              $flussoId[$i] = $fase['id_fase'];
              $flussoNome[$i] = $fase['descrizione'];
              // cerco le azioni associate( array contentente un array di azioni)
              $azioniAssociate[$i] = $db->getAzioniDaIdFase($flussoId[$i]);
              // get nodo successore con tutti i suoi dati
              $nodoSuccessore = $db->getNodoSuccessore($TipoProcessoSanzionatorio, $nodoCorrente);
              // nuovo nodo corrente è il nodo successore
              $nodoCorrente = $nodoSuccessore['id_fase'];
              }


              if ($i == $MAX_CICLI) { // se sono andato oltre il max cicli
              $this->_forward('error', 'Error');
              }
             */
            // view
            //print_r($flussoNome);*/
            $this->view->flusso_id = $flusso_id;
            $this->view->flusso_nome = $flusso_nome;
            $this->view->azioni_associate = $azioni_associate;
            $this->view->azioni_eseguite = $azioni_eseguite;
            $this->view->fasi_seguenti = $fasi_seguenti;
            $this->view->fase_effettuata = $fase_effettuata;
            $this->view->id_processo = $id_processo;
        } else {
            $this->_forward('index', 'Auth');
        }
    }

    /**
     * Questo metodo gestisce la creazione di un nuovo processo:
     * da alla view un'insieme di pulsanti ciascuno per un tipo do processo che poi
     * permettono di creare un nuovo processo di un dato tipo con l'azione
     * creaNuovoProcessoFase2 che gestirà poi l'associazione
     * a più persone di un processo
     *
     *
     *
     *
     */
    public function creaNuovoProcessoAction() {

        $auth = Zend_Auth::getInstance();
        if ($auth->hasIdentity()) {
            // creo gestore db
            require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
            $db = new Flusso_db();
            // prendo tutti i tipi di processo (Array di array)
            $processi = $db->getTipiProcesso();
            $this->view->processi = $processi;
        } else {
            $this->_forward('index', 'Auth');
        }
        //print_r($processi);
    }

    /**
     * Questo metodo dopo avere richiesto il tipo di responsabile
     * chiama process_selezione_tipo_responsabile che scrive il resonsabile nel db
     *
     * manca la scelta della data
     * manca l'aggiunta di responsabili
     * se id tipo processo null errore
     *
     *
     *
     */
    public function creaNuovoProcessoFase2Action() {
        $auth = Zend_Auth::getInstance();
        if ($auth->hasIdentity()) {
            $id = $auth->getIdentity()->id_utente;

            // prendo l'id admin
            $form = new Application_Form_SelezioneTipoResponsabile();
            $form->populate(array(
                'id_admin' => $id,
            ));

            $request = $this->getRequest();

            if ($request->isPost()) {
                if ($form->isValid($request->getPost())) {
                    $id_tipo_processo = $this->_process_selezione_tipo_responsabile($form->getValues());
                    if ($id_tipo_processo) { // se ho ritornato l'id processo
                        $urlOptions = array('controller' => 'gestione', 'action' => 'crea-nuovo-processo-fase3', 'id' => $id_tipo_processo);
                        //$this->view->notifica = "Ok.";
                        $this->_helper->redirector->gotoRoute($urlOptions, 'gestione');
                    } else {
                        $urlOptions = array('controller' => 'gestione', 'action' => 'crea-nuovo-processo-fase2');
                        $this->_helper->redirector->gotoRoute($urlOptions, 'gestione');
                        //$this->view->notifica = "Ops, si è verificato un errore.";
                    }
                }
            }
            $this->view->form = $form;
        } else {
            $this->_forward('index', 'Auth');
        }
    }

    /**
     * Questo metodo scrive nel database:
     * il processo
     * l'azione_eseguita
     * il responsabile
     *
     * aggiusta id azione (serve una query)
     * aggiusta i default: se pfisica contravventore se giuridica resp in solido
     *
     * @param type $values 
     *
     *
     */
    protected function _process_selezione_tipo_responsabile($values) {

        // Dati per tutte le tabelle
        $id_utente_creazione_record = $values['id_admin'];
        $id_utente_modifica_record = $values['id_admin'];
        // prende la data di oggi e la formatta
        $timestamp = time();
        $today = mktime(date("H", $timestamp), date("i", $timestamp), date("s", $timestamp), date("m", $timestamp), date("d", $timestamp), date("Y", $timestamp));
        $today = date("Y-m-d H:i:s", $today);
        $time_creazione_record = $today; // aggiusta
        $time_modifica_record = $today; // aggiusta
        $time_disattivazione_record = null; // aggiusta
        $time_eliminazione_record = null; // aggiusta
        $record_attivo = 1;



        // CREAZIONE PROCESSO
        // dati per nuovo processo
        // prendo l'id della persiona selezionata
        $sessions = new Zend_Session_Namespace('id_persona');
        $id_persona = $sessions->id_persona;
        $id_tipo_processo = $this->_getParam('id', 'nid');
        // prendo la data odierna
        $timestamp = time();
        $today = mktime(0, 0, 0, date("m", $timestamp), date("d", $timestamp), date("Y", $timestamp));
        $today = date("Y-m-d", $today);

        // fase db
        // creo gestore db generico
        require_once APPLICATION_PATH . '/models/Db/Db_Generico_db.php';
        $db = new Db_Generico_db();
        // creo gestore db flusso
        require_once APPLICATION_PATH . '/models/Db/Flusso_db.php';
        $db_flusso = new Flusso_db();

        //inizializzo la fase attuale del processo come sua radice (nodo con padre 0 dello stesso tipo processo)
        $id_fase_attuale = $db_flusso->getIdRadice($id_tipo_processo);

        //var_dump($id_fase_attuale);
        // preparo i dati per il nuovo processo
        $data_processo = array(
            "id_lib_tipo_processo_sanzionatorio" => $id_tipo_processo,
            "id_fase_attuale" => $id_fase_attuale['id_fase'],
            "data_inizio" => $today,
            "id_utente_creazione_record" => $id_utente_creazione_record,
            "id_utente_modifica_record" => $id_utente_modifica_record,
            "time_creazione_record" => $time_creazione_record, // aggiusta
            "time_modifica_record" => $time_modifica_record, // aggiusta
            "time_disattivazione_record" => $time_disattivazione_record, // aggiusta
            "time_eliminazione_record" => $time_eliminazione_record, // aggiusta
            "record_attivo" => $record_attivo,
        );
        // inserisco il nuovo processo con data odierna e prendo l'id processo
        $id_processo = $db->inserisciLastID($data_processo, 'processo_sanzionatorio');

        $id_azione = 16; // bisogna fare una query che prende 
        // l'id azione dal tipo di processo -> fase 
        // CREAZIONE AZIONE ESEGUITA
        //preparo i dati per l'inserimento nel db dio azione eseguita
        $data_azione_eseguita = array(
            "id_processo_sanzionatorio" => $id_processo,
            "id_azione" => $id_azione,
            "id_utente_esecutore" => $id_utente_creazione_record,
            "time_esecuzione_azione" => $today,
            "modificabile" => 0, //  non modificabile
            "id_utente_creazione_record" => $id_utente_creazione_record,
            "id_utente_modifica_record" => $id_utente_modifica_record,
            "time_creazione_record" => $today,
            "time_modifica_record" => $today,
            "time_disattivazione_record" => null,
            "time_eliminazione_record" => null,
            "record_attivo" => $record_attivo,
        );
        //fase db
        // inserisco azione eseguita
        $id_azione = $db->inserisciLastID($data_azione_eseguita, 'azione_eseguita');


        // CREAZIONE RESPONSABILE
        // dati per responsabile
        $tipo_responsabile = $values['tipo_responsabile'];
        // preparo i dati per il responsabile
        $data_responsabile = array(
            "id_azione_eseguita" => $id_azione,
            "id_persona" => $id_persona,
            "tipo_responsabile" => $tipo_responsabile,
            "id_utente_creazione_record" => $id_utente_creazione_record,
            "id_utente_modifica_record" => $id_utente_modifica_record,
            "time_creazione_record" => $time_creazione_record, // aggiusta
            "time_modifica_record" => $time_modifica_record, // aggiusta
            "time_disattivazione_record" => $time_disattivazione_record, // aggiusta
            "time_eliminazione_record" => $time_eliminazione_record, // aggiusta
            "record_attivo" => $record_attivo,
        );
        // inserisco il responsabile
        $ret = $db->inserisci($data_responsabile, 'responsabile');

        // stampa test
        //var_dump($data_processo);
        //var_dump($data_azione_eseguita);
        //var_dump($data_responsabile);

        return $id_processo; // non ho incontrato errori
    }

    /**
     * Metodo parte finale della creazione di processo
     * che permette all'utente di andare al processo creato e eseguire le azioni
     *
     */
    public function creaNuovoProcessoFase3Action() {
        $id_tipo_processo = $this->_getParam('id', 'nid');
        $this->view->id_processo = $id_tipo_processo;
    }

    /**
     * Questo metodo aggiorna la nuova fase corrente di un processo
     */
    public function settaNuovaFaseAction() {
        //id fase
        $id_fase = $this->_getParam('id', 'nid');
        //id processo
        $id_processo = $this->_getParam('id_processo', 'nid');

        // setto la nuova fase corrente
        require_once APPLICATION_PATH . "/models/Db/Flusso_db.php";
        $db_flusso = new Flusso_db();
        $db_flusso->aggiornaFaseCorrenteProcesso($id_fase, $id_processo);
        $urlOptions = array('controller' => 'gestione', 'action' => 'get-flusso','id'=>$id_processo);
        $this->_helper->redirector->gotoRoute($urlOptions, 'gestione');
    }

}

